home *** CD-ROM | disk | FTP | other *** search
/ Champak 50 / Volume 50 - JOGO DISK .iso / Games / money_maze.swf / scripts / DefineSprite_421 / frame_1 / DoAction.as
Text File  |  2007-09-27  |  37KB  |  1,450 lines
  1. function loadSoundFromLib(sName, sVolume)
  2. {
  3.    MCCreated++;
  4.    var _loc2_ = createEmptyMovieClip("mc" + MCCreated,MCCreated);
  5.    var _loc1_ = new Sound(_loc2_);
  6.    _loc1_.attachSound(sName);
  7.    _loc1_.setVolume(sVolume);
  8.    return _loc1_;
  9. }
  10. function playSound(oSoundObj, iRepeat)
  11. {
  12.    oSoundObj.start(0,Number(iRepeat));
  13. }
  14. function MazeClass(mc, sLinkID, iLevelFrame)
  15. {
  16.    var _loc1_ = this;
  17.    _loc1_.rows = [];
  18.    _loc1_.objects = [];
  19.    _loc1_.allFlags = [];
  20.    _loc1_.displayList = [];
  21.    _loc1_.doors = [];
  22.    _loc1_.target = mc;
  23.    _loc1_.level = mc.attachMovie(sLinkID,"mcLevel",10);
  24.    _loc1_.level.gotoAndStop(iLevelFrame + 5);
  25.    _loc1_.level.mc._visible = false;
  26.    _loc1_.viewPort = new _loc1_.ViewPortClass(_loc1_,ScreenWidth,ScreenHeight);
  27. }
  28. function OpponentClass(sChar)
  29. {
  30.    var _loc1_ = this;
  31.    _loc1_.speed = 150;
  32.    _loc1_.width = 50;
  33.    _loc1_.height = 60;
  34.    _loc1_.state = 0;
  35.    _loc1_.linkageID = sChar;
  36.    _loc1_.canBeTrapped = true;
  37.    _loc1_.keyUp = _loc1_.keyDown = false;
  38. }
  39. function MainCharClass()
  40. {
  41.    var _loc1_ = this;
  42.    _loc1_.speed = 300;
  43.    _loc1_.width = 50;
  44.    _loc1_.height = 60;
  45.    _loc1_.state = 0;
  46.    _loc1_.canUseSafe = true;
  47.    _loc1_.canCollectTokens = true;
  48. }
  49. function createObject(oGame, mc)
  50. {
  51.    var _loc1_ = mc;
  52.    var _loc2_ = oGame;
  53.    _loc1_._visible = false;
  54.    switch(_loc1_.type)
  55.    {
  56.       case "floor":
  57.          return null;
  58.       case "wall":
  59.          _loc2_.addWall(_loc1_._x,_loc1_._y);
  60.          break;
  61.       case "stairs":
  62.          var o = {x:_loc1_._x + 1,y:0};
  63.          _loc1_.localToGlobal(o);
  64.          var _loc3_ = o.x;
  65.          var o = {x:_loc1_._x,y:0};
  66.          _loc2_.addStairs(_loc1_._x,_loc1_._y,_loc1_.mc._rotation + 90,_loc3_ < o.x);
  67.          break;
  68.       case "safe":
  69.          _loc2_.addSafe(_loc1_);
  70.          break;
  71.       case "spawnpoint":
  72.          _loc2_.addSpawnPoint(_loc1_._x,_loc1_._y);
  73.          break;
  74.       case "door":
  75.          _loc1_._visible = true;
  76.          _loc2_.addDoor(_loc1_);
  77.          break;
  78.       case "trap":
  79.          _loc2_.addTrap(_loc1_);
  80.          break;
  81.       default:
  82.          _loc1_._visible = true;
  83.    }
  84. }
  85. function checkTrap(oFlag)
  86. {
  87.    var _loc1_ = oFlag;
  88.    var _loc2_ = this;
  89.    if(!_loc2_.canBeTrapped || !_loc1_.active)
  90.    {
  91.       return null;
  92.    }
  93.    _loc2_.trapped = _loc1_;
  94.    mcInterface.setCaught(true);
  95.    _loc1_.mc.gotoAndPlay("catch");
  96.    _loc1_.active = false;
  97.    _loc2_.wait = 3;
  98. }
  99. function collectRemote(oFlag)
  100. {
  101.    var _loc1_ = oFlag;
  102.    if(this.canCollectTokens && !_loc1_.disabled && this.layer == 0)
  103.    {
  104.       _loc1_.disabled = true;
  105.       _loc1_.target._visible = false;
  106.       setTrapState(true,10000);
  107.    }
  108. }
  109. function collectToken(oFlag)
  110. {
  111.    var _loc1_ = oFlag;
  112.    if(this.canCollectTokens && _loc1_.target._visible == true && this.layer == 0)
  113.    {
  114.       tokensRemaining--;
  115.       tokensCollected++;
  116.       _loc1_.disabled = true;
  117.       _loc1_.target._visible = false;
  118.       onTokenCollected(_loc1_.value);
  119.    }
  120. }
  121. function checkIfInDoor(oFlag)
  122. {
  123.    var _loc1_ = oFlag;
  124.    var _loc2_ = this;
  125.    if(Math.abs(_loc1_.mc._x - _loc2_.x) < _loc1_.hWidth)
  126.    {
  127.       _loc2_.currentDoor = _loc1_.mc;
  128.    }
  129.    else
  130.    {
  131.       _loc2_.currentDoor = null;
  132.    }
  133. }
  134. function enterSafe(oFlag)
  135. {
  136.    this.currentSafe = oFlag.mc;
  137. }
  138. function exitSafe(oFlag)
  139. {
  140.    this.currentSafe = null;
  141. }
  142. function useSafe(o, oFlag)
  143. {
  144.    if(tokensCollected <= 0)
  145.    {
  146.       return 0;
  147.    }
  148.    __totalBank = tokensBanked + tokensCollected;
  149.    var _loc1_ = new CallStackClass(gameUpdateInterval);
  150.    _loc1_.append(playMovieClip,oFlag.mcSafe,"open");
  151.    _loc1_.append(depositMoney,Math.ceil(tokensCollected * 0.01));
  152.    _loc1_.append(setObjectProp,o,"state",0);
  153.    _loc1_.start();
  154.    o.state = 1;
  155. }
  156. function depositMoney(iPerStep)
  157. {
  158.    var _loc1_ = Math.min(tokensCollected,iPerStep);
  159.    tokensBanked += _loc1_;
  160.    tokensCollected -= _loc1_;
  161.    onDepositCash(iPerStep);
  162.    updateInterface();
  163.    if(tokensCollected > 0)
  164.    {
  165.       return false;
  166.    }
  167.    tokensCollected = 0;
  168.    tokensBanked = __totalBank;
  169.    return true;
  170. }
  171. function setTrapState(bActive, iMsTime)
  172. {
  173.    var _loc2_ = bActive;
  174.    var _loc3_ = iMsTime;
  175.    var _loc1_ = 0;
  176.    while(_loc1_ < Game.traps.length)
  177.    {
  178.       Game.traps[_loc1_].active = _loc2_;
  179.       Game.traps[_loc1_].mc.gotoAndStop(!_loc2_ ? "off" : "on");
  180.       if(_loc2_)
  181.       {
  182.          TrapTimeRemaining = _loc3_;
  183.       }
  184.       else
  185.       {
  186.          TrapTimeRemaining = 0;
  187.       }
  188.       CollectedMoney = !_loc2_;
  189.       _loc1_ = _loc1_ + 1;
  190.    }
  191.    mcInterface.setTrapsActive(_loc2_);
  192. }
  193. function alignRightOfFlag(oFlag)
  194. {
  195.    var _loc1_ = this;
  196.    _loc1_.moveTo(oFlag.x + _loc1_.halfWidth + 0.01,_loc1_.y);
  197. }
  198. function alignLeftOfFlag(oFlag)
  199. {
  200.    var _loc1_ = this;
  201.    _loc1_.moveTo(oFlag.x - _loc1_.halfWidth - 0.01,_loc1_.y);
  202. }
  203. function goUpStairs(oFlag)
  204. {
  205.    var _loc1_ = this;
  206.    if(_loc1_.vDir <= 0)
  207.    {
  208.       return null;
  209.    }
  210.    orientToFlag(_loc1_,oFlag);
  211.    _loc1_.setLayer(1);
  212. }
  213. function goDownStairs(oFlag)
  214. {
  215.    var _loc1_ = this;
  216.    if(_loc1_.vDir >= 0)
  217.    {
  218.       return null;
  219.    }
  220.    orientToFlag(_loc1_,oFlag);
  221.    _loc1_.setLayer(1);
  222. }
  223. function getOffStairs(oFlag)
  224. {
  225.    var _loc1_ = this;
  226.    _loc1_.upX = 0;
  227.    _loc1_.upY = 1;
  228.    _loc1_.rightX = 1;
  229.    _loc1_.rightY = 0;
  230.    _loc1_.setLayer(0);
  231.    _loc1_.moveTo(_loc1_.x,oFlag.y);
  232. }
  233. function orientToFlag(oRef, oFlag)
  234. {
  235.    var _loc1_ = oRef;
  236.    var _loc2_ = oFlag;
  237.    _loc1_.upX = _loc2_.upX;
  238.    _loc1_.upY = _loc2_.upY;
  239.    _loc1_.rightX = _loc2_.rightX;
  240.    _loc1_.rightY = _loc2_.rightY;
  241.    var _loc3_ = _loc1_.x - _loc2_.x;
  242.    _loc1_.x = _loc2_.x;
  243.    _loc1_.y = _loc2_.y;
  244.    _loc1_.moveBy(_loc3_ * _loc1_.rightX,_loc3_ * _loc1_.rightY);
  245. }
  246. function isBetween(iNum, i0, i1)
  247. {
  248.    var _loc1_ = iNum;
  249.    var _loc2_ = i1;
  250.    var _loc3_ = i0;
  251.    if(_loc3_ < _loc2_)
  252.    {
  253.       ┬º┬ºpush(_loc1_ >= _loc3_);
  254.       if(_loc1_ >= _loc3_)
  255.       {
  256.          ┬º┬ºpop();
  257.          return _loc1_ < _loc2_;
  258.       }
  259.    }
  260.    ┬º┬ºpush(_loc1_ > _loc2_);
  261.    if(_loc1_ > _loc2_)
  262.    {
  263.       ┬º┬ºpop();
  264.       return _loc1_ <= _loc3_;
  265.    }
  266. }
  267. function goThruDoor(o, oDoor)
  268. {
  269.    var _loc3_ = undefined;
  270.    var _loc1_ = 0;
  271.    while(_loc1_ < Game.doors.length)
  272.    {
  273.       _loc3_ = Game.doors[_loc1_];
  274.       if(_loc3_.id == oDoor.id && oDoor != _loc3_)
  275.       {
  276.          var targetDoor = o.currentDoor = Game.doors[_loc1_];
  277.          break;
  278.       }
  279.       _loc1_ = _loc1_ + 1;
  280.    }
  281.    var T;
  282.    var _loc2_ = new CallStackClass(gameUpdateInterval);
  283.    _loc2_.append(playMovieClip,oDoor.mcDoor,"open");
  284.    _loc2_.append(_loc2_.wait,300);
  285.    T = addTweenToStack(_loc2_).createNewTween(o.target);
  286.    T.addPosition(0.1,oDoor._x,oDoor._y);
  287.    T = addTweenToStack(_loc2_).createNewTween(o.target);
  288.    T.addOffsetTint(0.1,0,0,0,0,-255,-255,-255,-255);
  289.    _loc2_.append(playMovieClip,oDoor.mcDoor,"close");
  290.    _loc2_.append(_loc2_.wait,150);
  291.    _loc2_.append(moveObject,o,targetDoor._x,targetDoor._y);
  292.    _loc2_.append(_loc2_.wait,100);
  293.    _loc2_.append(playMovieClip,targetDoor.mcDoor,"open");
  294.    _loc2_.append(_loc2_.wait,500);
  295.    T = addTweenToStack(_loc2_).createNewTween(o.target);
  296.    T.addOffsetTint(0.1,-255,-255,-255,-255,0,0,0,0);
  297.    _loc2_.append(setObjectProp,o,"state",0);
  298.    _loc2_.append(playMovieClip,targetDoor.mcDoor,"close");
  299.    _loc2_.start();
  300.    o.state = 1;
  301. }
  302. function playMovieClip(mc, sFrame)
  303. {
  304.    mc.gotoAndPlay(sFrame);
  305. }
  306. function moveObject(o, iX, iY)
  307. {
  308.    o.moveTo(iX,iY);
  309. }
  310. function setObjectProp(o, sProp, vValue)
  311. {
  312.    o[sProp] = vValue;
  313. }
  314. function waitForElements()
  315. {
  316.    if(Game.prep == null)
  317.    {
  318.       return false;
  319.    }
  320.    Game.setupElements();
  321.    return true;
  322. }
  323. function gotoLevel(iLevel)
  324. {
  325.    Game.mcLevel._visible = false;
  326.    currentLevel = iLevel;
  327.    var _loc1_ = new CallStackClass(32);
  328.    if(Game != null)
  329.    {
  330.       _loc1_.append(removeCurrentGame);
  331.    }
  332.    _loc1_.append(createNewMaze,iLevel);
  333.    _loc1_.append(waitForElements);
  334.    _loc1_.append(setupLevel);
  335.    _loc1_.append(beginGame);
  336.    _loc1_.start();
  337. }
  338. function createNewMaze(iLevel)
  339. {
  340.    var _loc1_ = createEmptyMovieClip("mcStage",0);
  341.    Game = new MazeClass(_loc1_,"levels",iLevel);
  342.    tokensCollected = 0;
  343.    tokensBanked = 0;
  344. }
  345. function beginGame()
  346. {
  347.    updateInterface();
  348.    if(MovieClip.prototype._gameIntervalID != null)
  349.    {
  350.       clearInterval(MovieClip.prototype._gameIntervalID);
  351.    }
  352.    MovieClip.prototype._gameIntervalID = setInterval(updateGame,gameUpdateInterval);
  353.    Game.level.mc._visible = true;
  354.    lastTime = getTimer() * 0.001;
  355.    active = true;
  356.    unpause();
  357.    MainChar.moveCharacter(0.01,false,false,true,false);
  358.    updateGame();
  359. }
  360. function updateGame()
  361. {
  362.    var _loc1_ = Math.min(0.04,- lastTime + (lastTime = getTimer() * 0.001));
  363.    if(paused || !active)
  364.    {
  365.       return null;
  366.    }
  367.    checkTraps(_loc1_);
  368.    Game.step(_loc1_,2);
  369.    updateAfterEvent();
  370. }
  371. function checkTraps(elapsed)
  372. {
  373.    if(TrapTimeRemaining <= 0)
  374.    {
  375.       return null;
  376.    }
  377.    TrapTimeRemaining -= elapsed;
  378.    if(TrapTimeRemaining <= 0)
  379.    {
  380.       setTrapState(false);
  381.    }
  382. }
  383. function endGame()
  384. {
  385. }
  386. function setupLevel()
  387. {
  388.    var _loc1_ = undefined;
  389.    var _loc0_ = null;
  390.    var _loc2_ = mainChar = Game.createObject(MainCharClass);
  391.    _loc2_.alignTo(Game.entryPoint[0]);
  392.    Game.Viewport.addWatch(_loc2_);
  393.    switch(currentLevel % 3)
  394.    {
  395.       case 0:
  396.          _loc1_ = "charRaven";
  397.          break;
  398.       case 1:
  399.          _loc1_ = "charMom";
  400.          break;
  401.       case 2:
  402.          _loc1_ = "charDad";
  403.    }
  404.    _loc2_ = Game.createObject(OpponentClass,_loc1_);
  405.    _loc2_.alignTo(Game.entryPoint[1]);
  406.    CreateTokens("_ITEM_COIN");
  407.    i = 0;
  408.    while(i < Game.rows.length)
  409.    {
  410.       Game.rows[i].flags.bubbleSortOn("x");
  411.       i++;
  412.    }
  413.    setTrapState(false);
  414. }
  415. function pause()
  416. {
  417.    if(active)
  418.    {
  419.       paused = true;
  420.    }
  421. }
  422. function unpause()
  423. {
  424.    paused = false;
  425. }
  426. function loseLife()
  427. {
  428.    lives--;
  429.    pause();
  430.    if(lives <= 0)
  431.    {
  432.       _root.gotoAndStop("GameLose");
  433.    }
  434.    else
  435.    {
  436.       mcInterface.mcDialog.showDialog("loseLife");
  437.       updateInterface();
  438.    }
  439. }
  440. function createTokens(sIdentifier)
  441. {
  442.    var a;
  443.    var r;
  444.    var _loc2_ = undefined;
  445.    var tokens;
  446.    var xSpace;
  447.    var xSpan;
  448.    var _loc3_ = undefined;
  449.    var _loc1_ = undefined;
  450.    var remoteUsed;
  451.    tokensRemaining = 0;
  452.    var i = 0;
  453.    while(i < Game.rows.length)
  454.    {
  455.       remoteUsed = false;
  456.       r = Game.rows[i];
  457.       a = r.flags;
  458.       _loc2_ = [];
  459.       _loc1_ = 0;
  460.       while(_loc1_ < a.length)
  461.       {
  462.          _loc2_.push(a[_loc1_].x);
  463.          _loc1_ = _loc1_ + 1;
  464.       }
  465.       _loc2_.sortNumbers();
  466.       xSpan = _loc2_[_loc2_.length - 1] - _loc2_[0];
  467.       tokens = Math.floor(xSpan / tokenWidth);
  468.       xSpace = xSpan / tokens;
  469.       _loc3_ = _loc2_[0];
  470.       _loc1_ = 0;
  471.       while(_loc1_ < tokens - 1)
  472.       {
  473.          _loc3_ += xSpace;
  474.          if(!remoteUsed && random(tokens - 4) == 0)
  475.          {
  476.             Game.addRemote(_loc3_,r.y,"remote");
  477.             remoteUsed = true;
  478.          }
  479.          else
  480.          {
  481.             tokensTotal = tokensRemaining++;
  482.             Game.addToken(_loc3_,r.y,sIdentifier,Number(random(4) == 0));
  483.          }
  484.          _loc1_ = _loc1_ + 1;
  485.       }
  486.       i++;
  487.    }
  488.    trace(tokensTotal);
  489. }
  490. function startNewGame()
  491. {
  492.    lives = 3;
  493.    mcInterface.setScore(0);
  494.    gotoLevel(1);
  495. }
  496. function addBonus(iAmmount)
  497. {
  498.    bonusAmmount += iAmmount;
  499.    playSound(sndBank);
  500.    mcInterface.appendScore(iAmmount);
  501.    mcInterface.mcDialog.bonusAmmount = "$" + bonusAmmount;
  502. }
  503. function endLevel()
  504. {
  505.    bonusAmmount = 0;
  506.    mcInterface.mcDialog.bonusAmmount = "$0";
  507.    active = false;
  508.    var _loc1_ = new CallStackClass(10);
  509.    _loc1_.append(mcInterface.mcDialog.showDialog,"bonus");
  510.    _loc1_.append(_loc1_.wait,1000);
  511.    if(lives >= 1)
  512.    {
  513.       _loc1_.append(addBonus,1000);
  514.       _loc1_.append(_loc1_.wait,300);
  515.    }
  516.    if(lives >= 2)
  517.    {
  518.       _loc1_.append(addBonus,4000);
  519.       _loc1_.append(_loc1_.wait,300);
  520.    }
  521.    if(lives >= 3)
  522.    {
  523.       _loc1_.append(addBonus,5000);
  524.       _loc1_.append(_loc1_.wait,300);
  525.    }
  526.    _loc1_.append(_loc1_.wait,700);
  527.    if(currentLevel == 3)
  528.    {
  529.       _loc1_.append(setTimeOut,gotoEnd,100);
  530.    }
  531.    else
  532.    {
  533.       _loc1_.append(mcInterface.mcDialog.showDialog,"endLevel");
  534.       _loc1_.append(endGame);
  535.    }
  536.    _loc1_.start();
  537. }
  538. function gotoEnd()
  539. {
  540.    _root.gotoAndStop("gameWin");
  541. }
  542. function gotoNextLevel()
  543. {
  544.    currentLevel++;
  545.    if(currentLevel > 3)
  546.    {
  547.       _root.gotoAndStop("gameWin");
  548.    }
  549.    else
  550.    {
  551.       gotoLevel(currentLevel);
  552.    }
  553. }
  554. function onTokenCollected(iValue)
  555. {
  556.    playSound(sndCollectCash,0);
  557.    mcInterface.appendScore(iValue * 50 + 50);
  558. }
  559. function onDepositCash(fNumber)
  560. {
  561.    mcInterface.appendScore(50 * fNumber);
  562.    if(tokensCollected == 0 && tokensBanked >= tokensTotal)
  563.    {
  564.       endLevel();
  565.    }
  566. }
  567. function onCollision(oA, oB)
  568. {
  569.    var _loc1_ = oB;
  570.    var _loc2_ = oA;
  571.    if(!_loc1_.trapped && !_loc2_.trapped)
  572.    {
  573.       _loc2_.alignTo(Game.entryPoint[0]);
  574.       _loc1_.alignTo(Game.entryPoint[1]);
  575.       _loc2_.resetVector();
  576.       _loc1_.resetVector();
  577.       _loc2_.layer = _loc1_.layer = 0;
  578.       pause();
  579.       loseLife();
  580.    }
  581.    else
  582.    {
  583.       if(CollectedMoney)
  584.       {
  585.          return null;
  586.       }
  587.       playSound(sndBank,0);
  588.       mcInterface.appendScore(5000);
  589.       CollectedMoney = true;
  590.    }
  591. }
  592. function onObjectsUpdate(oGame)
  593. {
  594.    var _loc3_ = oGame;
  595.    var _loc1_ = undefined;
  596.    var _loc2_ = 1;
  597.    while(_loc2_ < _loc3_.objects.length)
  598.    {
  599.       _loc1_ = _loc3_.objects[_loc2_];
  600.       if(!(MainChar.row != _loc1_.row || MainChar.state == 1 || _loc1_.state == 1))
  601.       {
  602.          if(MainChar.layer == _loc1_.layer)
  603.          {
  604.             if(!(Math.abs(MainChar.x - _loc1_.x) > MainChar.halfWidth || Math.abs(MainChar.y - _loc1_.y) > 20))
  605.             {
  606.                onCollision(MainChar,_loc1_);
  607.                break;
  608.             }
  609.          }
  610.       }
  611.       _loc2_ = _loc2_ + 1;
  612.    }
  613. }
  614. function updateInterface()
  615. {
  616.    var _loc1_ = int(tokensCollected);
  617.    var _loc2_ = int(tokensBanked);
  618.    if(_loc1_ != mcInterface.tokensCollected)
  619.    {
  620.       mcInterface.tokensCollected = _loc1_;
  621.    }
  622.    if(_loc2_ != mcInterface.tokensBanked)
  623.    {
  624.       mcInterface.tokensBanked = _loc2_;
  625.    }
  626.    if(lives != 0)
  627.    {
  628.       mcInterface.mcLives.gotoAndStop(lives);
  629.    }
  630. }
  631. mcInterface.swapDepths(10000);
  632. rowAdjust = 20;
  633. gameUpdateInterval = 10;
  634. active = false;
  635. ScreenWidth = 595;
  636. ScreenHeight = 440;
  637. tokenWidth = 40;
  638. currentLevel = 1;
  639. wallThickness = 10;
  640. paused = false;
  641. FLAG_AXIS = 1;
  642. FLAG_BOUNDS = 2;
  643. FLAG_LEFT_BOUNDS = 3;
  644. FLAG_RIGHT_BOUNDS = 4;
  645. MovieClip.prototype.registerElement = function(sType, mc)
  646. {
  647.    Game.elementToPrep(sType,mc);
  648. };
  649. MovieClip.prototype.drawLine = function(sX, sY, eX, eY)
  650. {
  651.    moveTo(sX,sY);
  652.    lineStyle(1,0,100);
  653.    lineTo(eX,eY);
  654. };
  655. sndCollectCash = loadSoundFromLib("CollectMoney",50);
  656. sndBank = loadSoundFromLib("Money",500);
  657. MCP = MazeClass.prototype;
  658. MCP.ViewPortClass = function(oWorld, iWidth, iHeight)
  659. {
  660.    var _loc1_ = this;
  661.    var _loc2_ = oWorld;
  662.    _loc1_.width = iWidth;
  663.    _loc1_.height = iHeight;
  664.    var hWidth = _loc1_.hWidth = iWidth * 0.5;
  665.    var _loc0_ = null;
  666.    var _loc3_ = _loc1_.hHieght = iHeight * 0.5;
  667.    _loc1_.levelWidth = _loc2_.target._width - _loc3_ * 0.25;
  668.    _loc1_.levelHeight = _loc2_.target._height;
  669.    _loc1_.world = _loc2_;
  670.    _loc1_.watch = [];
  671. };
  672. VCP = MCP.ViewPortClass.prototype;
  673. VCP.addWatch = function(oRef)
  674. {
  675.    if(this.watch.indexOf(oRef) == -1)
  676.    {
  677.       this.watch.push(oRef);
  678.    }
  679. };
  680. VCP.removeWatch = function(oRef)
  681. {
  682.    this.watch.remove(oRef);
  683. };
  684. VCP.update = function()
  685. {
  686.    var _loc3_ = this;
  687.    var _loc1_ = undefined;
  688.    if(_loc3_.watch.length == 1)
  689.    {
  690.       _loc1_ = _loc3_.watch[0];
  691.       _loc3_.x = _loc1_.x;
  692.       _loc3_.y = _loc1_.y;
  693.    }
  694.    else
  695.    {
  696.       var L = oWorld.target._width;
  697.       var R = 0;
  698.       var T = oWorld.target._height;
  699.       var B = 0;
  700.       var _loc2_ = 0;
  701.       while(_loc2_ < _loc3_.watch.length)
  702.       {
  703.          _loc1_ = _loc3_.watch[_loc2_];
  704.          L = Math.min(L,_loc1_.x);
  705.          R = Math.max(R,_loc1_.x);
  706.          T = Math.min(T,_loc1_.y);
  707.          B = Math.max(B,_loc1_.y);
  708.          _loc2_ = _loc2_ + 1;
  709.       }
  710.    }
  711.    var xspan = - (_loc3_.x - _loc3_.hWidth) - _loc3_.world.target._x;
  712.    var xDir = xspan <= 0 ? -1 : 1;
  713.    if(Math.abs(xspan) > _loc3_.hwidth * 0.4)
  714.    {
  715.       var x = - _loc3_.x + xDir * _loc3_.hWidth * 0.3;
  716.       x = - Math.min(Math.max(_loc3_.hWidth,- x),_loc3_.levelWidth) + _loc3_.hWidth;
  717.       if(_loc3_.world.target._x != x)
  718.       {
  719.          _loc3_.world.target._x = x;
  720.       }
  721.    }
  722. };
  723. MCP.RowClass = function(iY)
  724. {
  725.    this.y = iY;
  726.    this.flags = [];
  727. };
  728. RCP = MCP.RowClass.prototype;
  729. RCP.addFlag = function(o)
  730. {
  731.    this.flags.push(o);
  732. };
  733. MCP.FlagClass = function(iType, iX, iY, fnLtR, fnRtL)
  734. {
  735.    var _loc1_ = this;
  736.    _loc1_.x = iX;
  737.    _loc1_.y = iY;
  738.    _loc1_.disabled = false;
  739.    _loc1_.type = iType;
  740.    _loc1_.leftToRight = fnLtR;
  741.    _loc1_.rightToLeft = fnRtL;
  742. };
  743. MCP.findRowNumber = function(iY)
  744. {
  745.    var _loc2_ = this;
  746.    var _loc3_ = iY;
  747.    var _loc1_ = 0;
  748.    while(_loc1_ < _loc2_.rows.length)
  749.    {
  750.       if(_loc3_ < _loc2_.rows[_loc1_].y + RowAdjust)
  751.       {
  752.          return _loc1_;
  753.       }
  754.       _loc1_ = _loc1_ + 1;
  755.    }
  756.    return 0;
  757. };
  758. MCP.elementToPrep = function(sType, mc)
  759. {
  760.    var _loc1_ = this;
  761.    var _loc2_ = mc;
  762.    var _loc3_ = sType;
  763.    if(_loc1_.prep == null)
  764.    {
  765.       _loc1_.prep = {};
  766.       _loc1_.prep.all = [];
  767.    }
  768.    _loc2_.type = _loc3_.toLowerCase();
  769.    if(_loc1_.prep[_loc3_] == null)
  770.    {
  771.       _loc1_.prep[_loc3_] = [_loc2_];
  772.    }
  773.    else
  774.    {
  775.       _loc1_.prep[_loc3_].push(_loc2_);
  776.    }
  777.    _loc1_.prep.all.push(_loc2_);
  778. };
  779. MCP.createFlag = function(iType, iX, iY, fnLtR, fnRtL, sName)
  780. {
  781.    var _loc3_ = this;
  782.    var _loc2_ = _loc3_.findRowNumber(iY);
  783.    var _loc1_ = new _loc3_.FlagClass(iType,iX,_loc3_.rows[_loc2_].y,fnLtR,fnRtL);
  784.    _loc3_.rows[_loc2_].addFlag(_loc1_);
  785.    _loc1_.name = sName;
  786.    return _loc1_;
  787. };
  788. MCP.createObject = function(cn)
  789. {
  790.    var _loc1_ = arguments;
  791.    var _loc2_ = new cn(_loc1_[1],_loc1_[2],_loc1_[3],_loc1_[4]);
  792.    this.objects.push(_loc2_);
  793.    _loc2_.init(this);
  794.    return _loc2_;
  795. };
  796. MCP.createRow = function(iY)
  797. {
  798.    var _loc1_ = new this.RowClass(iY);
  799.    this.rows.push(_loc1_);
  800. };
  801. MCP.setupElements = function()
  802. {
  803.    var _loc2_ = this;
  804.    var _loc3_ = _loc2_.prep.floor;
  805.    var _loc1_ = 0;
  806.    while(_loc1_ < _loc3_.length)
  807.    {
  808.       _loc2_.createRow(_loc3_[_loc1_]._y);
  809.       _loc1_ = _loc1_ + 1;
  810.    }
  811.    _loc2_.rows.sortOn("y");
  812.    var mc;
  813.    _loc3_ = _loc2_.prep.all;
  814.    _loc1_ = 0;
  815.    while(_loc1_ < _loc3_.length)
  816.    {
  817.       createObject(_loc2_,_loc3_[_loc1_]);
  818.       _loc1_ = _loc1_ + 1;
  819.    }
  820.    var rooms = _loc2_.rooms = [];
  821.    _loc1_ = 0;
  822.    while(_loc1_ < _loc2_.rows.length)
  823.    {
  824.       _loc2_.rows[_loc1_].flags.bubbleSortOn("x");
  825.       _loc2_.findRoomsOnRow(_loc1_);
  826.       _loc1_ = _loc1_ + 1;
  827.    }
  828. };
  829. MCP.findRoomsOnRow = function(iRow)
  830. {
  831.    var _loc3_ = undefined;
  832.    var _loc1_ = undefined;
  833.    a = this.rows[iRow].flags;
  834.    var i = 0;
  835.    while(i < a.length - 1)
  836.    {
  837.       _loc3_ = a[i];
  838.       switch(_loc3_.name)
  839.       {
  840.          case "wallright":
  841.             _loc1_ = {};
  842.             _loc1_.branches = [];
  843.             _loc1_.left = _loc3_.x;
  844.             _loc1_.row = iRow;
  845.             break;
  846.          case "wallleft":
  847.             if(_loc1_ != null)
  848.             {
  849.                _loc1_.right = _loc3_.x;
  850.                var _loc2_ = 0;
  851.                while(_loc2_ < _loc1_.branches.length)
  852.                {
  853.                   _loc1_.branches[_loc2_].room = _loc0_ = this.rooms.length;
  854.                   _loc1_.branches[_loc2_].flag.room = _loc0_;
  855.                   _loc2_ = _loc2_ + 1;
  856.                }
  857.                _loc1_.id = this.rooms.length;
  858.                this.rooms.push(_loc1_);
  859.                _loc1_ = null;
  860.             }
  861.             break;
  862.          case "door":
  863.             i++;
  864.             _loc1_.branches.push({flag:_loc3_,type:_loc3_.name,x:_loc3_.mc._x,row:iRow,id:_loc3_.id});
  865.             break;
  866.          case "stairsup":
  867.          case "stairsdown":
  868.             _loc1_.branches.push({flag:_loc3_,type:_loc3_.name,x:_loc3_.x,row:iRow});
  869.             break;
  870.       }
  871.       i++;
  872.    }
  873. };
  874. MCP.addSpawnPoint = function(iX, iY)
  875. {
  876.    var _loc1_ = this;
  877.    var _loc3_ = _loc1_.findRowNumber(iY);
  878.    var _loc2_ = {x:iX,y:_loc1_.rows[_loc3_].y};
  879.    if(_loc1_.entryPoint == null)
  880.    {
  881.       _loc1_.entrypoint = [_loc2_];
  882.    }
  883.    else
  884.    {
  885.       _loc1_.entryPoint.push(_loc2_);
  886.    }
  887. };
  888. MCP.addToken = function(iX, iY, sLinkage, iFrame)
  889. {
  890.    var _loc2_ = this.createFlag(FLAG_BOUNDS,iX,iY,collectToken,collectToken,"token");
  891.    var _loc0_ = null;
  892.    var _loc1_ = _loc2_.target = this.addMovieToLevel(sLinkage);
  893.    _loc1_._x = iX;
  894.    _loc1_._y = iY;
  895.    _loc1_.gotoAndStop(iFrame + 1);
  896.    _loc2_.value = iFrame;
  897. };
  898. MCP.addRemote = function(iX, iY, sLinkage)
  899. {
  900.    var _loc2_ = this.createFlag(FLAG_BOUNDS,iX,iY,collectRemote,collectRemote,"remote");
  901.    var _loc0_ = null;
  902.    var _loc1_ = _loc2_.target = this.addMovieToLevel(sLinkage);
  903.    _loc1_._x = iX;
  904.    _loc1_._y = iY;
  905.    _loc1_.gotoAndStop(iFrame + 1);
  906.    _loc2_.value = iFrame;
  907. };
  908. MCP.addTrap = function(mc)
  909. {
  910.    var _loc1_ = mc;
  911.    var _loc2_ = this;
  912.    _loc1_._visible = true;
  913.    var rowNum = _loc2_.findRowNumber(_loc1_._y);
  914.    var _loc3_ = _loc2_.createFlag(FLAG_AXIS,_loc1_._x,_loc1_._y,checkTrap,checkTrap,"trap");
  915.    _loc3_.mc = _loc1_;
  916.    if(_loc2_.traps == null)
  917.    {
  918.       _loc2_.traps = [];
  919.    }
  920.    _loc2_.traps.push(_loc3_);
  921. };
  922. MCP.addWall = function(iX, iY)
  923. {
  924.    var _loc1_ = undefined;
  925.    _loc1_ = this.createFlag(FLAG_LEFT_BOUNDS,iX + wallThickness,iY,null,alignRightOfFlag,"wallright");
  926.    _loc1_ = this.createFlag(FLAG_RIGHT_BOUNDS,iX,iY,alignLeftOfFlag,null,"wallleft");
  927. };
  928. MCP.addDoor = function(mc)
  929. {
  930.    var _loc2_ = mc;
  931.    var _loc3_ = this;
  932.    var rowNum = _loc3_.findRowNumber(_loc2_._y);
  933.    _loc2_._y = _loc3_.rows[rowNum];
  934.    var hWidth = _loc2_._width * 0.5;
  935.    var lFlag = _loc3_.createFlag(FLAG_AXIS,_loc2_._x - hWidth,_loc2_._y,checkIfInDoor,checkIfInDoor,"door");
  936.    var rFlag = _loc3_.createFlag(FLAG_AXIS,_loc2_._x + hWidth,_loc2_._y,checkIfInDoor,checkIfInDoor,"door");
  937.    rFlag.mc = lFlag.mc = _loc2_;
  938.    rFlag.mcDoor = lFlag.mcDoor = _loc2_.mcDoor;
  939.    rFlag.id = lFlag.id = _loc2_.id;
  940.    rFlag.hWidth = lFlag.hWidth = hWidth;
  941.    _loc2_.lFlag = lFlag;
  942.    _loc2_.rFlag = rFlag;
  943.    var _loc1_ = 0;
  944.    while(_loc1_ < _loc3_.doors.length)
  945.    {
  946.       if(_loc3_.doors[_loc1_].id == _loc2_.id)
  947.       {
  948.          _loc3_.doors[_loc1_].lFlag.other = _loc2_.lFlag;
  949.          _loc3_.doors[_loc1_].rFlag.other = _loc2_.rFlag;
  950.          _loc2_.lFlag.other = _loc3_.doors[_loc1_].lFlag;
  951.          _loc2_.rFlag.other = _loc3_.doors[_loc1_].rFlag;
  952.       }
  953.       _loc1_ = _loc1_ + 1;
  954.    }
  955.    _loc3_.doors.push(_loc2_);
  956. };
  957. MCP.addSafe = function(mc)
  958. {
  959.    var _loc1_ = mc;
  960.    var _loc2_ = this;
  961.    var _loc3_ = _loc2_.findRowNumber(_loc1_._y);
  962.    _loc1_._y = _loc2_.rows[_loc3_].y;
  963.    _loc1_._visible = true;
  964.    var left = _loc2_.createFlag(FLAG_AXIS,_loc1_._x,_loc1_._y,enterSafe,exitSafe,"safe");
  965.    var right = _loc2_.createFlag(FLAG_AXIS,_loc1_._x + 50,_loc1_._y,exitSafe,enterSafe,"safe");
  966.    left.mc = right.mc = _loc1_;
  967. };
  968. MCP.addStairs = function(iX, iY, iAngle, bFlipped)
  969. {
  970.    StairsCreated++;
  971.    var rowNum = this.findRowNumber(iY);
  972.    iY = this.rows[rowNum].y;
  973.    var fRad;
  974.    var vX;
  975.    var _loc3_ = undefined;
  976.    var upX;
  977.    var upY;
  978.    var rightX;
  979.    var rightY;
  980.    var topX;
  981.    var topY;
  982.    fRad = (iAngle - 180) / 180 * 3.1415;
  983.    vX = Math.sin(fRad);
  984.    _loc3_ = Math.cos(fRad);
  985.    upX = - _loc3_;
  986.    upY = vX;
  987.    var bLtR;
  988.    var bRtL;
  989.    var tLtR;
  990.    var tRtL;
  991.    if(bFlipped)
  992.    {
  993.       bRtL = goUpStairs;
  994.       tLtR = goDownStairs;
  995.       bLtR = tRtL = getOffStairs;
  996.       rightX = - upY;
  997.       rightY = upX;
  998.    }
  999.    else
  1000.    {
  1001.       bLtR = goUpStairs;
  1002.       tRtL = goDownStairs;
  1003.       bRtL = tLtR = getOffStairs;
  1004.       rightX = - upY;
  1005.       rightY = - upX;
  1006.       bFlipped = -1;
  1007.    }
  1008.    var spanY = iY - this.rows[rowNum - 1].y;
  1009.    var dist = Math.abs(1 / _loc3_) * spanY;
  1010.    topX = iX + vX * bFlipped * dist;
  1011.    topY = iY + _loc3_ * dist;
  1012.    var _loc1_ = this.createFlag(FLAG_AXIS,iX,iY,bLtR,bRtL,"stairsup");
  1013.    var _loc2_ = this.createFlag(FLAG_AXIS,topX,topY,tLtR,tRtL,"stairsdown");
  1014.    _loc2_.flipped = _loc1_.flipped = bFlipped;
  1015.    _loc2_.upX = _loc1_.upX = upX;
  1016.    _loc2_.upY = _loc1_.upY = upY;
  1017.    _loc2_.rightX = _loc1_.rightX = rightX;
  1018.    _loc2_.rightY = _loc1_.rightY = rightY;
  1019.    _loc2_.id = _loc1_.id = StairsCreated;
  1020.    _loc2_.other = _loc1_;
  1021.    _loc1_.other = _loc2_;
  1022. };
  1023. MCP.step = function(fStepSize, iCount)
  1024. {
  1025.    var _loc2_ = iCount;
  1026.    var _loc3_ = this;
  1027.    _loc2_ = Math.max(_loc2_,1);
  1028.    fStepSize /= _loc2_;
  1029.    var _loc1_ = 0;
  1030.    while(_loc1_ < _loc2_)
  1031.    {
  1032.       _loc3_.updateObjects(fStepSize);
  1033.       _loc1_ = _loc1_ + 1;
  1034.    }
  1035.    _loc3_.updateDisplay();
  1036.    _loc3_.viewport.update();
  1037. };
  1038. MCP.updateObjects = function(fStepSize)
  1039. {
  1040.    var _loc2_ = this;
  1041.    var _loc3_ = fStepSize;
  1042.    var _loc1_ = 0;
  1043.    while(_loc1_ < _loc2_.objects.length)
  1044.    {
  1045.       _loc2_.objects[_loc1_].update(_loc3_);
  1046.       _loc1_ = _loc1_ + 1;
  1047.    }
  1048.    onObjectsUpdate(_loc2_);
  1049. };
  1050. MCP.addMovieToLevel = function(sLinkageID)
  1051. {
  1052.    var _loc1_ = this;
  1053.    _loc1_.movieClipsCreated = _loc1_.movieClipsCreated + 1;
  1054.    var _loc2_ = _loc1_.target.mcLevel.attachMovie(sLinkageID,"mc" + _loc1_.movieClipsCreated,_loc1_.movieClipsCreated - 1000);
  1055.    return _loc2_;
  1056. };
  1057. MCP.queueForDisplay = function(oRef)
  1058. {
  1059.    var _loc1_ = oRef;
  1060.    if(_loc1_.queued)
  1061.    {
  1062.       return null;
  1063.    }
  1064.    _loc1_.queued = true;
  1065.    this.displayList.push(_loc1_);
  1066. };
  1067. MCP.updateDisplay = function()
  1068. {
  1069.    var _loc2_ = this;
  1070.    if(_loc2_.displayList.length == 0)
  1071.    {
  1072.       return null;
  1073.    }
  1074.    var _loc1_ = 0;
  1075.    while(_loc1_ < _loc2_.displayList.length)
  1076.    {
  1077.       _loc2_.displayList[_loc1_].updateDisplay();
  1078.       _loc2_.displayList[_loc1_].queued = false;
  1079.       _loc1_ = _loc1_ + 1;
  1080.    }
  1081.    _loc2_.displayList = [];
  1082. };
  1083. MCP.GenericObject = function(sLinkageID)
  1084. {
  1085.    var _loc1_ = this;
  1086.    _loc1_.linkageID = sLinkageID;
  1087.    _loc1_.upX = 0;
  1088.    _loc1_.upY = 1;
  1089.    _loc1_.rightX = 1;
  1090.    _loc1_.rightY = 0;
  1091.    _loc1_.setLayer(0);
  1092. };
  1093. GOP = MCP.GenericObject.prototype;
  1094. GOP.moveTo = function(iX, iY)
  1095. {
  1096.    var _loc1_ = this;
  1097.    var _loc2_ = _loc1_.x != (_loc1_.x = iX);
  1098.    _loc2_ = _loc1_.y != (_loc1_.y = iY) || _loc2_;
  1099.    if(!_loc2_)
  1100.    {
  1101.       return null;
  1102.    }
  1103.    _loc1_.level.queueForDisplay(_loc1_);
  1104. };
  1105. GOP.moveBy = function(iX, iY)
  1106. {
  1107.    var _loc1_ = this;
  1108.    _loc1_.moveTo(_loc1_.x + iX,_loc1_.y + iY);
  1109. };
  1110. GOP.alignTo = function(oRef)
  1111. {
  1112.    this.moveTo(oRef.x,oRef.y);
  1113. };
  1114. GOP.init = function(oLevel)
  1115. {
  1116.    var _loc1_ = this;
  1117.    _loc1_.halfWidth = _loc1_.width * 0.5;
  1118.    _loc1_.level = oLevel;
  1119.    _loc1_.target = oLevel.addMovieToLevel(_loc1_.linkageID);
  1120. };
  1121. GOP.setLayer = function(iLevel)
  1122. {
  1123.    this.layer = iLevel;
  1124. };
  1125. GOP.updateDisplay = function()
  1126. {
  1127.    var _loc1_ = this;
  1128.    mc = _loc1_.target;
  1129.    mc._x = _loc1_.x;
  1130.    mc._y = _loc1_.y;
  1131. };
  1132. GOP.getCurrentRoom = function(iX, iRow)
  1133. {
  1134.    var _loc3_ = iX;
  1135.    var _loc2_ = this.level.rooms;
  1136.    var _loc1_ = 0;
  1137.    while(_loc1_ < _loc2_.length)
  1138.    {
  1139.       if(_loc2_[_loc1_].row == iRow)
  1140.       {
  1141.          if(_loc3_ < _loc2_[_loc1_].right && _loc3_ > _loc2_[_loc1_].left)
  1142.          {
  1143.             return this.level.rooms[_loc1_];
  1144.          }
  1145.       }
  1146.       _loc1_ = _loc1_ + 1;
  1147.    }
  1148. };
  1149. GOP.findPath = function(iX, iRow)
  1150. {
  1151.    var _loc1_ = this;
  1152.    _loc1_.row = _loc1_.level.findRowNumber(_loc1_.y);
  1153.    if(iRow == null)
  1154.    {
  1155.       return null;
  1156.    }
  1157.    var _loc2_ = _loc1_.getCurrentRoom(iX,iRow);
  1158.    var _loc3_ = _loc1_.getCurrentRoom(_loc1_.x,_loc1_.row);
  1159.    _root.path = _loc1_.path = _loc1_.testPathNode([],_loc3_,_loc2_,iX,_loc1_.x);
  1160. };
  1161. GOP.testPathNode = function(aRoomsUsed, oRoom, oTarget, iTarX, iLastX)
  1162. {
  1163.    var _loc3_ = oRoom;
  1164.    if(aRoomsUsed[_loc3_.id])
  1165.    {
  1166.       return null;
  1167.    }
  1168.    aRoomsUsed[_loc3_.id] = true;
  1169.    var v;
  1170.    var path;
  1171.    var branch;
  1172.    var _loc1_ = undefined;
  1173.    var tmpX;
  1174.    if(_loc3_.id == oTarget.id)
  1175.    {
  1176.       return [{room:_loc3_.id,x:iTarX}];
  1177.    }
  1178.    var _loc2_ = 0;
  1179.    while(_loc2_ < _loc3_.branches.length)
  1180.    {
  1181.       branch = _loc3_.branches[_loc2_];
  1182.       v = this.testPathNode(aRoomsUsed,this.level.rooms[branch.flag.other.room],oTarget,iTarX,branch.flag.x);
  1183.       if(v != null)
  1184.       {
  1185.          _loc1_ = branch.flag;
  1186.          v.unshift({room:_loc3_.id,x:(_loc1_.name != "door" ? _loc1_.x : _loc1_.mc._x),flag:_loc1_});
  1187.          aRoomsUsed[_loc3_.id] = null;
  1188.          return v;
  1189.       }
  1190.       _loc2_ = _loc2_ + 1;
  1191.    }
  1192.    aRoomsUsed[_loc3_.id] = null;
  1193. };
  1194. GOP.moveCharacter = function(fElapsed, bLeft, bUp, bRight, bDown)
  1195. {
  1196.    var _loc2_ = this;
  1197.    var oldX = _loc2_.x;
  1198.    var oldY = _loc2_.y;
  1199.    _loc2_.hDir = bRight - bLeft;
  1200.    _loc2_.vDir = bUp - bDown;
  1201.    if(_loc2_.hDir != 0)
  1202.    {
  1203.       _loc2_.fDir = _loc2_.hDir;
  1204.    }
  1205.    if(bUp)
  1206.    {
  1207.       if(_loc2_.currentDoor != null)
  1208.       {
  1209.          goThruDoor(_loc2_,_loc2_.currentDoor);
  1210.       }
  1211.       if(_loc2_.canUseSafe && _loc2_.currentSafe != null)
  1212.       {
  1213.          useSafe(_loc2_,_loc2_.currentSafe);
  1214.       }
  1215.    }
  1216.    if(!_loc2_.walk(_loc2_.hDir,fElapsed))
  1217.    {
  1218.       return false;
  1219.    }
  1220.    var _loc1_ = undefined;
  1221.    var aFlags = _loc2_.level.rows[_loc2_.row].flags;
  1222.    var oLX;
  1223.    var oRX;
  1224.    var nLX;
  1225.    var nRX;
  1226.    oLX = oldX - _loc2_.halfWidth;
  1227.    oRX = oldX + _loc2_.halfWidth;
  1228.    nLX = _loc2_.x - _loc2_.halfWidth;
  1229.    nRX = _loc2_.x + _loc2_.halfWidth;
  1230.    var iLeft = Math.min(oLX,nLX);
  1231.    var iRight = Math.max(oRX,nRX);
  1232.    var _loc3_ = 0;
  1233.    for(; _loc3_ < aFlags.length; _loc3_ = _loc3_ + 1)
  1234.    {
  1235.       _loc1_ = aFlags[_loc3_];
  1236.       _loc2_.__tmpfnltr = _loc1_.leftToRight;
  1237.       _loc2_.__tmpfnrtl = _loc1_.rightToLeft;
  1238.       if(_loc1_.disabled)
  1239.       {
  1240.          continue;
  1241.       }
  1242.       if(_loc1_.x < iLeft)
  1243.       {
  1244.          continue;
  1245.       }
  1246.       if(_loc1_.x > iRight)
  1247.       {
  1248.          break;
  1249.       }
  1250.       switch(_loc1_.type)
  1251.       {
  1252.          case FLAG_AXIS:
  1253.             if(isBetween(_loc1_.x,oldX,_loc2_.x))
  1254.             {
  1255.                if(_loc2_.hDir == 1)
  1256.                {
  1257.                   _loc2_.__tmpfnltr(_loc1_);
  1258.                }
  1259.                else
  1260.                {
  1261.                   _loc2_.__tmpfnrtl(_loc1_);
  1262.                }
  1263.             }
  1264.             continue;
  1265.          case FLAG_BOUNDS:
  1266.             if(isBetween(_loc1_.x,oLX,nLX) || isBetween(_loc1_.x,oRX,nRX))
  1267.             {
  1268.                if(_loc2_.hDir == 1)
  1269.                {
  1270.                   _loc2_.__tmpfnltr(_loc1_);
  1271.                }
  1272.                else
  1273.                {
  1274.                   _loc2_.__tmpfnrtl(_loc1_);
  1275.                }
  1276.             }
  1277.             continue;
  1278.          case FLAG_LEFT_BOUNDS:
  1279.             if(isBetween(_loc1_.x,oLX,nLX))
  1280.             {
  1281.                if(_loc2_.hDir == 1)
  1282.                {
  1283.                   _loc2_.__tmpfnltr(_loc1_);
  1284.                }
  1285.                else
  1286.                {
  1287.                   _loc2_.__tmpfnrtl(_loc1_);
  1288.                }
  1289.             }
  1290.             continue;
  1291.          case FLAG_RIGHT_BOUNDS:
  1292.             if(isBetween(_loc1_.x,oRX,nRX))
  1293.             {
  1294.                if(_loc2_.hDir == 1)
  1295.                {
  1296.                   _loc2_.__tmpfnltr(_loc1_);
  1297.                }
  1298.                else
  1299.                {
  1300.                   _loc2_.__tmpfnrtl(_loc1_);
  1301.                }
  1302.             }
  1303.             continue;
  1304.          default:
  1305.             continue;
  1306.       }
  1307.    }
  1308. };
  1309. GOP.walk = function(iDir, fElapsed)
  1310. {
  1311.    var _loc1_ = this;
  1312.    if(iDir == 0)
  1313.    {
  1314.       _loc1_.target.gotoAndStop(_loc1_.fDir != 1 ? "stand_l" : "stand_r");
  1315.       return false;
  1316.    }
  1317.    var _loc2_ = iDir * fElapsed * _loc1_.speed;
  1318.    _loc1_.moveBy(_loc2_ * _loc1_.rightX,_loc2_ * _loc1_.rightY);
  1319.    _loc1_.target.gotoAndStop(_loc1_.fDir != 1 ? "walk_l" : "walk_r");
  1320.    _loc1_.row = _loc1_.level.findRowNumber(_loc1_.y);
  1321.    return true;
  1322. };
  1323. GOP.resetVector = function()
  1324. {
  1325.    var _loc1_ = this;
  1326.    _loc1_.upX = 0;
  1327.    _loc1_.upY = 1;
  1328.    _loc1_.rightX = 1;
  1329.    _loc1_.rightY = 0;
  1330. };
  1331. OpponentClass.prototype = new MCP.GenericObject();
  1332. OCP = OpponentClass.prototype;
  1333. OCP.findNewPath = function(bNotChar)
  1334. {
  1335.    var _loc1_ = undefined;
  1336.    var _loc2_ = undefined;
  1337.    var _loc3_ = undefined;
  1338.    if(random(4) == 1 && MainChar.row != null && !bNotChar)
  1339.    {
  1340.       _loc3_ = MainChar.x;
  1341.       _loc2_ = MainChar.row;
  1342.    }
  1343.    else
  1344.    {
  1345.       _loc1_ = this.level.rooms[random(this.level.rooms.length)];
  1346.       _loc3_ = _loc1_.left + random(_loc1_.right - _loc1_.left - 200) + 100;
  1347.       _loc2_ = _loc1_.row;
  1348.    }
  1349.    this.findPath(_loc3_,_loc2_);
  1350. };
  1351. OCP.update = function(fElapsed)
  1352. {
  1353.    var _loc1_ = this;
  1354.    var _loc3_ = fElapsed;
  1355.    if(_loc1_.wait > 0)
  1356.    {
  1357.       TrapTimeRemaining = 0;
  1358.       _loc1_.trapped = true;
  1359.       _loc1_.wait -= _loc3_;
  1360.       if(_loc1_.wait <= 0)
  1361.       {
  1362.          _loc1_.trapped = false;
  1363.          _loc1_.trapped.mc.gotoAndPlay("release");
  1364.          mcInterface.setCaught(false);
  1365.          setTrapState(false);
  1366.       }
  1367.       return null;
  1368.    }
  1369.    if(_loc1_.state == 0 && MainChar.state == 0)
  1370.    {
  1371.       if(_loc1_.path.length == 0 || _loc1_.path == null)
  1372.       {
  1373.          _loc1_.findNewPath();
  1374.       }
  1375.       else
  1376.       {
  1377.          var _loc2_ = _loc1_.path[0];
  1378.          var distX = Math.abs(_loc2_.x - _loc1_.x);
  1379.          _loc1_.reaction += _loc3_;
  1380.          if(_loc1_.layer == 0 && _loc1_.reaction > 0.1)
  1381.          {
  1382.             _loc1_.reaction = 0;
  1383.             var sNext = _loc2_.flag.name;
  1384.             _loc1_.reaction += _loc3_;
  1385.             _loc1_.keyLeft = _loc2_.x < _loc1_.x;
  1386.             _loc1_.keyRight = _loc2_.x > _loc1_.x;
  1387.             var changed = _loc1_.zone != (_loc1_.zone = Math.floor(_loc1_.x / 80));
  1388.             if(!changed)
  1389.             {
  1390.                _loc1_.timeIn += _loc3_;
  1391.             }
  1392.             else
  1393.             {
  1394.                _loc1_.timeIn = 0;
  1395.             }
  1396.             if(distX < 48)
  1397.             {
  1398.                switch(sNext)
  1399.                {
  1400.                   case "stairsdown":
  1401.                      _loc1_.keyDown = true;
  1402.                      goNext = true;
  1403.                      break;
  1404.                   case "stairsup":
  1405.                      _loc1_.keyUp = true;
  1406.                      goNext = true;
  1407.                      break;
  1408.                   case "door":
  1409.                      _loc1_.keyUp = true;
  1410.                      goNext = true;
  1411.                      break;
  1412.                   case undefined:
  1413.                   case null:
  1414.                      _loc1_.keyRight = _loc0_ = false;
  1415.                      _loc1_.keyLeft = _loc0_;
  1416.                      _loc1_.keyDown = _loc0_;
  1417.                      _loc1_.keyUp = _loc0_;
  1418.                      _loc1_.findNewPath();
  1419.                }
  1420.             }
  1421.             else
  1422.             {
  1423.                _loc1_.keyDown = _loc0_ = false;
  1424.                _loc1_.keyUp = _loc0_;
  1425.             }
  1426.          }
  1427.          if(_loc1_.timeIn > 0.25)
  1428.          {
  1429.             _loc1_.findNewPath();
  1430.             _loc1_.timeIn = 0;
  1431.          }
  1432.          _loc1_.moveCharacter(_loc3_,_loc1_.keyLeft,_loc1_.keyUp,_loc1_.keyRight,_loc1_.keyDown);
  1433.          if((_loc1_.layer == 1 || _loc1_.state != 0) && goNext)
  1434.          {
  1435.             _loc1_.keyDown = _loc0_ = false;
  1436.             _loc1_.keyUp = _loc0_;
  1437.             _loc1_.path.shift();
  1438.          }
  1439.       }
  1440.    }
  1441. };
  1442. MainCharClass.prototype = new MCP.GenericObject("mainChar");
  1443. MainCharClass.prototype.update = function(fElapsed)
  1444. {
  1445.    if(this.state == 0)
  1446.    {
  1447.       this.moveCharacter(fElapsed,Key.isDown(37),Key.isDown(38),Key.isDown(39),Key.isDown(40));
  1448.    }
  1449. };
  1450.